package registnet.dao;

import java.sql.Connection;
import java.sql.SQLException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;

import org.apache.torque.NoRowsException;
import org.apache.torque.TooManyRowsException;
import org.apache.torque.Torque;
import org.apache.torque.TorqueException;
import org.apache.torque.map.MapBuilder;
import org.apache.torque.map.TableMap;
import org.apache.torque.om.ObjectKey;
import org.apache.torque.om.SimpleKey;
import org.apache.torque.util.BasePeer;
import org.apache.torque.util.Criteria;

import registnet.dao.map.ClassroomViewMapBuilder;

import com.workingdogs.village.DataSetException;
import com.workingdogs.village.QueryDataSet;
import com.workingdogs.village.Record;

/**
 * This class was autogenerated by Torque on: [Tue Mar 10 18:48:40 CST 2009]
 */
public abstract class BaseClassroomViewPeer extends BasePeer {

	/**
	 * 
	 */
	private static final long serialVersionUID = 2596472825790070762L;

	/** the default database name for this class */
	public static final String DATABASE_NAME = "RegistNetDB";

	/** the table name for this class */
	public static final String TABLE_NAME = "classroom_view";

	/** the column name for the CLASSROOMID field */
	public static final String CLASSROOMID;

	/** the column name for the CLASSROOMCODE field */
	public static final String CLASSROOMCODE;
	/** the column name for the CAPACITY field */
	public static final String CAPACITY;
	/** the column name for the ROOMCATEGORY field */
	public static final String ROOMCATEGORY;
	/** number of columns for this peer */
	public static final int numColumns = 4;

	/** A class that can be returned by this peer. */
	protected static final String CLASSNAME_DEFAULT = "registnet.dao.ClassroomView";

	/** A class that can be returned by this peer. */
	protected static final Class CLASS_DEFAULT = initClass(CLASSNAME_DEFAULT);

	static {
		CLASSROOMID = "classroom_view.CLASSROOMID";
		CLASSROOMCODE = "classroom_view.CLASSROOMCODE";
		CAPACITY = "classroom_view.CAPACITY";
		ROOMCATEGORY = "classroom_view.ROOMCATEGORY";
		if (Torque.isInit()) {
			try {
				getMapBuilder(ClassroomViewMapBuilder.CLASS_NAME);
			} catch (final Exception e) {
				log.error("Could not initialize Peer", e);
			}
		} else {
			Torque.registerMapBuilder(ClassroomViewMapBuilder.CLASS_NAME);
		}
	}

	/**
	 * Add all the columns needed to create a new object.
	 * 
	 * @param criteria
	 *            object containing the columns to add.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void addSelectColumns(final Criteria criteria)
			throws TorqueException {
		criteria.addSelectColumn(CLASSROOMID);
		criteria.addSelectColumn(CLASSROOMCODE);
		criteria.addSelectColumn(CAPACITY);
		criteria.addSelectColumn(ROOMCATEGORY);
	}

	/** Build a Criteria object from the data object for this peer */
	public static Criteria buildCriteria(final ClassroomView obj) {
		final Criteria criteria = new Criteria(DATABASE_NAME);
		criteria.add(CLASSROOMID, obj.getClassroomId());
		if (!obj.isNew()) {
			criteria.add(CLASSROOMCODE, obj.getClassroomCode());
		}
		criteria.add(CAPACITY, obj.getCapacity());
		criteria.add(ROOMCATEGORY, obj.getRoomCategory());
		return criteria;
	}

	/** Build a Criteria object from an ObjectKey */
	public static Criteria buildCriteria(final ObjectKey pk) {
		final Criteria criteria = new Criteria();
		criteria.add(CLASSROOMCODE, pk);
		return criteria;
	}

	/**
	 * @param obj
	 *            the data object to delete in the database.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doDelete(final ClassroomView obj) throws TorqueException {
		doDelete(buildCriteria(obj));
	}

	/**
	 * Method to delete. This method is to be used during a transaction,
	 * otherwise use the doDelete(ClassroomView) method. It will take care of
	 * the connection details internally.
	 * 
	 * @param obj
	 *            the data object to delete in the database.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doDelete(final ClassroomView obj, final Connection con)
			throws TorqueException {
		doDelete(buildCriteria(obj), con);
	}

	/**
	 * Method to do deletes.
	 * 
	 * @param criteria
	 *            object containing data that is used DELETE from database.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doDelete(final Criteria criteria) throws TorqueException {
		BaseClassroomViewPeer.doDelete(criteria, (Connection) null);
	}

	/**
	 * Method to do deletes. This method is to be used during a transaction,
	 * otherwise use the doDelete(Criteria) method. It will take care of the
	 * connection details internally.
	 * 
	 * @param criteria
	 *            object containing data that is used DELETE from database.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doDelete(final Criteria criteria, final Connection con)
			throws TorqueException {

		// Set the correct dbName if it has not been overridden
		// criteria.getDbName will return the same object if not set to
		// another value so == check is okay and faster
		if (criteria.getDbName() == Torque.getDefaultDB()) {
			criteria.setDbName(DATABASE_NAME);
		}
		if (con == null) {
			BasePeer.doDelete(criteria);
		} else {
			BasePeer.doDelete(criteria, con);
		}
	}

	/**
	 * Method to do deletes.
	 * 
	 * @param pk
	 *            ObjectKey that is used DELETE from database.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doDelete(final ObjectKey pk) throws TorqueException {
		BaseClassroomViewPeer.doDelete(pk, (Connection) null);
	}

	/**
	 * Method to delete. This method is to be used during a transaction,
	 * otherwise use the doDelete(ObjectKey) method. It will take care of the
	 * connection details internally.
	 * 
	 * @param pk
	 *            the primary key for the object to delete in the database.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doDelete(final ObjectKey pk, final Connection con)
			throws TorqueException {
		doDelete(buildCriteria(pk), con);
	}

	/**
	 * Method to do inserts
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doInsert(final ClassroomView obj) throws TorqueException {
		obj.setPrimaryKey(doInsert(buildCriteria(obj)));
		obj.setNew(false);
		obj.setModified(false);
	}

	/**
	 * Method to do inserts. This method is to be used during a transaction,
	 * otherwise use the doInsert(ClassroomView) method. It will take care of
	 * the connection details internally.
	 * 
	 * @param obj
	 *            the data object to insert into the database.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doInsert(final ClassroomView obj, final Connection con)
			throws TorqueException {
		obj.setPrimaryKey(doInsert(buildCriteria(obj), con));
		obj.setNew(false);
		obj.setModified(false);
	}

	/**
	 * Method to do inserts.
	 * 
	 * @param criteria
	 *            object used to create the INSERT statement.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static ObjectKey doInsert(final Criteria criteria)
			throws TorqueException {
		return BaseClassroomViewPeer.doInsert(criteria, (Connection) null);
	}

	/**
	 * Method to do inserts. This method is to be used during a transaction,
	 * otherwise use the doInsert(Criteria) method. It will take care of the
	 * connection details internally.
	 * 
	 * @param criteria
	 *            object used to create the INSERT statement.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static ObjectKey doInsert(final Criteria criteria,
			final Connection con) throws TorqueException {

		// Set the correct dbName if it has not been overridden
		// criteria.getDbName will return the same object if not set to
		// another value so == check is okay and faster
		if (criteria.getDbName() == Torque.getDefaultDB()) {
			criteria.setDbName(DATABASE_NAME);
		}
		if (con == null) {
			return BasePeer.doInsert(criteria);
		} else {
			return BasePeer.doInsert(criteria, con);
		}
	}

	/**
	 * Method to do selects
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List doSelect(final ClassroomView obj) throws TorqueException {
		return doSelect(buildCriteria(obj));
	}

	/**
	 * Method to do selects.
	 * 
	 * @param criteria
	 *            object used to create the SELECT statement.
	 * @return List of selected Objects
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List doSelect(final Criteria criteria) throws TorqueException {
		return populateObjects(doSelectVillageRecords(criteria));
	}

	/**
	 * Method to do selects within a transaction.
	 * 
	 * @param criteria
	 *            object used to create the SELECT statement.
	 * @param con
	 *            the connection to use
	 * @return List of selected Objects
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List doSelect(final Criteria criteria, final Connection con)
			throws TorqueException {
		return populateObjects(doSelectVillageRecords(criteria, con));
	}

	/**
	 * Grabs the raw Village records to be formed into objects. This method
	 * handles connections internally. The Record objects returned by this
	 * method should be considered readonly. Do not alter the data and call
	 * save(), your results may vary, but are certainly likely to result in hard
	 * to track MT bugs.
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List doSelectVillageRecords(final Criteria criteria)
			throws TorqueException {
		return BaseClassroomViewPeer.doSelectVillageRecords(criteria,
				(Connection) null);
	}

	/**
	 * Grabs the raw Village records to be formed into objects. This method
	 * should be used for transactions
	 * 
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List doSelectVillageRecords(final Criteria criteria,
			final Connection con) throws TorqueException {
		if (criteria.getSelectColumns().size() == 0) {
			addSelectColumns(criteria);
		}

		// Set the correct dbName if it has not been overridden
		// criteria.getDbName will return the same object if not set to
		// another value so == check is okay and faster
		if (criteria.getDbName() == Torque.getDefaultDB()) {
			criteria.setDbName(DATABASE_NAME);
		}
		// BasePeer returns a List of Value (Village) arrays. The array
		// order follows the order columns were placed in the Select clause.
		if (con == null) {
			return BasePeer.doSelect(criteria);
		} else {
			return BasePeer.doSelect(criteria, con);
		}
	}

	/**
	 * @param obj
	 *            the data object to update in the database.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doUpdate(final ClassroomView obj) throws TorqueException {
		doUpdate(buildCriteria(obj));
		obj.setModified(false);
	}

	/**
	 * Method to do update. This method is to be used during a transaction,
	 * otherwise use the doUpdate(ClassroomView) method. It will take care of
	 * the connection details internally.
	 * 
	 * @param obj
	 *            the data object to update in the database.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doUpdate(final ClassroomView obj, final Connection con)
			throws TorqueException {
		doUpdate(buildCriteria(obj), con);
		obj.setModified(false);
	}

	/**
	 * Method to do updates.
	 * 
	 * @param criteria
	 *            object containing data that is used to create the UPDATE
	 *            statement.
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doUpdate(final Criteria criteria) throws TorqueException {
		BaseClassroomViewPeer.doUpdate(criteria, (Connection) null);
	}

	/**
	 * Method to do updates. This method is to be used during a transaction,
	 * otherwise use the doUpdate(Criteria) method. It will take care of the
	 * connection details internally.
	 * 
	 * @param criteria
	 *            object containing data that is used to create the UPDATE
	 *            statement.
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void doUpdate(final Criteria criteria, final Connection con)
			throws TorqueException {
		final Criteria selectCriteria = new Criteria(DATABASE_NAME, 2);
		selectCriteria.put(CLASSROOMCODE, criteria.remove(CLASSROOMCODE));

		// Set the correct dbName if it has not been overridden
		// criteria.getDbName will return the same object if not set to
		// another value so == check is okay and faster
		if (criteria.getDbName() == Torque.getDefaultDB()) {
			criteria.setDbName(DATABASE_NAME);
		}
		if (con == null) {
			BasePeer.doUpdate(selectCriteria, criteria);
		} else {
			BasePeer.doUpdate(selectCriteria, criteria, con);
		}
	}

	/**
	 * @return the map builder for this peer
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static MapBuilder getMapBuilder() throws TorqueException {
		return getMapBuilder(ClassroomViewMapBuilder.CLASS_NAME);
	}

	/**
	 * The class that the Peer will make instances of. If the BO is abstract
	 * then you must implement this method in the BO.
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static Class getOMClass() throws TorqueException {
		return CLASS_DEFAULT;
	}

	/**
	 * Returns the TableMap related to this peer. This method is not needed for
	 * general use but a specific application could have a need.
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	protected static TableMap getTableMap() throws TorqueException {
		return Torque.getDatabaseMap(DATABASE_NAME).getTable(TABLE_NAME);
	}

	/**
	 * Class object initialization method.
	 * 
	 * @param className
	 *            name of the class to initialize
	 * @return the initialized class
	 */
	private static Class initClass(final String className) {
		Class c = null;
		try {
			c = Class.forName(className);
		} catch (final Throwable t) {
			log
					.error(
							"A FATAL ERROR has occurred which should not "
									+ "have happened under any circumstance.  Please notify "
									+ "the Torque developers <torque-dev@db.apache.org> "
									+ "and give as many details as possible (including the error "
									+ "stack trace).", t);

			// Error objects should always be propogated.
			if (t instanceof Error) {
				throw (Error) t.fillInStackTrace();
			}
		}
		return c;
	}

	/**
	 * Populates an object from a resultset row starting from a specified
	 * offset. This is done so that you can select other rows than just those
	 * needed for this object. You may for example want to create two objects
	 * from the same row.
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static void populateObject(final Record row, final int offset,
			final ClassroomView obj) throws TorqueException {
		try {
			obj.setClassroomId(row.getValue(offset + 0).asInt());
			obj.setClassroomCode(row.getValue(offset + 1).asString());
			obj.setCapacity(row.getValue(offset + 2).asInt());
			obj.setRoomCategory(row.getValue(offset + 3).asString());
		} catch (final DataSetException e) {
			throw new TorqueException(e);
		}
	}

	/**
	 * The returned List will contain objects of the default type or objects
	 * that inherit from the default.
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List populateObjects(final List records)
			throws TorqueException {
		final List results = new ArrayList(records.size());

		// populate the object(s)
		for (int i = 0; i < records.size(); i++) {
			final Record row = (Record) records.get(i);
			results.add(BaseClassroomViewPeer.row2Object(row, 1,
					BaseClassroomViewPeer.getOMClass()));
		}
		return results;
	}

	/**
	 * Get the list of objects for a ResultSet. Please not that your resultset
	 * MUST return columns in the right order. You can use getFieldNames() in
	 * BaseObject to get the correct sequence.
	 * 
	 * @param results
	 *            the ResultSet
	 * @return the list of objects
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List resultSet2Objects(final java.sql.ResultSet results)
			throws TorqueException {
		try {
			QueryDataSet qds = null;
			List rows = null;
			try {
				qds = new QueryDataSet(results);
				rows = getSelectResults(qds);
			} finally {
				if (qds != null) {
					qds.close();
				}
			}

			return populateObjects(rows);
		} catch (final SQLException e) {
			throw new TorqueException(e);
		} catch (final DataSetException e) {
			throw new TorqueException(e);
		}
	}

	/**
	 * Retrieve a single object by pk
	 * 
	 * @param pk
	 *            the primary key
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 * @throws NoRowsException
	 *             Primary key was not found in database.
	 * @throws TooManyRowsException
	 *             Primary key was not found in database.
	 */
	public static ClassroomView retrieveByPK(final ObjectKey pk)
			throws TorqueException, NoRowsException, TooManyRowsException {
		Connection db = null;
		ClassroomView retVal = null;
		try {
			db = Torque.getConnection(DATABASE_NAME);
			retVal = retrieveByPK(pk, db);
		} finally {
			Torque.closeConnection(db);
		}
		return retVal;
	}

	/**
	 * Retrieve a single object by pk
	 * 
	 * @param pk
	 *            the primary key
	 * @param con
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 * @throws NoRowsException
	 *             Primary key was not found in database.
	 * @throws TooManyRowsException
	 *             Primary key was not found in database.
	 */
	public static ClassroomView retrieveByPK(final ObjectKey pk,
			final Connection con) throws TorqueException, NoRowsException,
			TooManyRowsException {
		final Criteria criteria = buildCriteria(pk);
		final List v = doSelect(criteria, con);
		if (v.size() == 0) {
			throw new NoRowsException("Failed to select a row.");
		} else if (v.size() > 1) {
			throw new TooManyRowsException("Failed to select only one row.");
		} else {
			return (ClassroomView) v.get(0);
		}
	}

	/**
	 * Retrieve a single object by pk
	 * 
	 * @param pk
	 *            the primary key
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 * @throws NoRowsException
	 *             Primary key was not found in database.
	 * @throws TooManyRowsException
	 *             Primary key was not found in database.
	 */
	public static ClassroomView retrieveByPK(final String pk)
			throws TorqueException, NoRowsException, TooManyRowsException {
		return retrieveByPK(SimpleKey.keyFor(pk));
	}

	/**
	 * Retrieve a multiple objects by pk
	 * 
	 * @param pks
	 *            List of primary keys
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List retrieveByPKs(final List pks) throws TorqueException {
		Connection db = null;
		List retVal = null;
		try {
			db = Torque.getConnection(DATABASE_NAME);
			retVal = retrieveByPKs(pks, db);
		} finally {
			Torque.closeConnection(db);
		}
		return retVal;
	}

	/**
	 * Retrieve a multiple objects by pk
	 * 
	 * @param pks
	 *            List of primary keys
	 * @param dbcon
	 *            the connection to use
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static List retrieveByPKs(final List pks, final Connection dbcon)
			throws TorqueException {
		List objs = null;
		if (pks == null || pks.size() == 0) {
			objs = new LinkedList();
		} else {
			final Criteria criteria = new Criteria();
			criteria.addIn(CLASSROOMCODE, pks);
			objs = doSelect(criteria, dbcon);
		}
		return objs;
	}

	/**
	 * Create a new object of type cls from a resultset row starting from a
	 * specified offset. This is done so that you can select other rows than
	 * just those needed for this object. You may for example want to create two
	 * objects from the same row.
	 * 
	 * @throws TorqueException
	 *             Any exceptions caught during processing will be rethrown
	 *             wrapped into a TorqueException.
	 */
	public static ClassroomView row2Object(final Record row, final int offset,
			final Class cls) throws TorqueException {
		try {
			final ClassroomView obj = (ClassroomView) cls.newInstance();
			BaseClassroomViewPeer.populateObject(row, offset, obj);
			obj.setModified(false);
			obj.setNew(false);

			return obj;
		} catch (final InstantiationException e) {
			throw new TorqueException(e);
		} catch (final IllegalAccessException e) {
			throw new TorqueException(e);
		}
	}
}
